{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eLCoypcao-88"
      },
      "source": [
        "对应`tf.kears` 版本的03，在训练过程中加入更多的控制\n",
        "\n",
        "1. 训练中保存/保存最好的模型\n",
        "2. 早停\n",
        "3. 训练过程可视化\n",
        "\n",
        "<font color=\"red\">注</font>: 使用 tensorboard 可视化需要安装 tensorflow (TensorBoard依赖于tensorflow库，可以任意安装tensorflow的gpu/cpu版本)\n",
        "\n",
        "```shell\n",
        "pip install tensorflow\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T01:57:02.285080600Z",
          "start_time": "2024-07-18T01:56:52.418388500Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "a8r3E3I1o-8-",
        "outputId": "7e58b83f-bc52-4ae7-fa20-e7a814efbe26"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "sys.version_info(major=3, minor=11, micro=11, releaselevel='final', serial=0)\n",
            "matplotlib 3.10.0\n",
            "numpy 1.26.4\n",
            "pandas 2.2.2\n",
            "sklearn 1.6.0\n",
            "torch 2.5.1+cu121\n",
            "cuda:0\n"
          ]
        }
      ],
      "source": [
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "import numpy as np\n",
        "import sklearn\n",
        "import pandas as pd\n",
        "import os\n",
        "import sys\n",
        "import time\n",
        "from tqdm.auto import tqdm\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "print(sys.version_info)\n",
        "for module in mpl, np, pd, sklearn, torch:\n",
        "    print(module.__name__, module.__version__)\n",
        "\n",
        "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
        "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ltV9TIsDo-8_"
      },
      "source": [
        "## 数据准备"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T01:57:51.324566200Z",
          "start_time": "2024-07-18T01:57:48.504779800Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wZl7JeAgo-8_",
        "outputId": "3d5624d6-fb6d-41fe-c649-91272d44c5b6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz to data/FashionMNIST/raw/train-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 26.4M/26.4M [00:02<00:00, 10.1MB/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/FashionMNIST/raw/train-images-idx3-ubyte.gz to data/FashionMNIST/raw\n",
            "\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw/train-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 29.5k/29.5k [00:00<00:00, 152kB/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/FashionMNIST/raw/train-labels-idx1-ubyte.gz to data/FashionMNIST/raw\n",
            "\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 4.42M/4.42M [00:01<00:00, 2.63MB/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/FashionMNIST/raw/t10k-images-idx3-ubyte.gz to data/FashionMNIST/raw\n",
            "\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz\n",
            "Downloading http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 5.15k/5.15k [00:00<00:00, 7.45MB/s]"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting data/FashionMNIST/raw/t10k-labels-idx1-ubyte.gz to data/FashionMNIST/raw\n",
            "\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n"
          ]
        }
      ],
      "source": [
        "from torchvision import datasets\n",
        "from torchvision.transforms import ToTensor\n",
        "\n",
        "# fashion_mnist图像分类数据集\n",
        "train_ds = datasets.FashionMNIST(\n",
        "    root=\"data\",\n",
        "    train=True,\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")\n",
        "\n",
        "test_ds = datasets.FashionMNIST(\n",
        "    root=\"data\",\n",
        "    train=False,\n",
        "    download=True,\n",
        "    transform=ToTensor()\n",
        ")\n",
        "\n",
        "# torchvision 数据集里没有提供训练集和验证集的划分\n",
        "# 当然也可以用 torch.utils.data.Dataset 实现人为划分"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T01:57:53.071712500Z",
          "start_time": "2024-07-18T01:57:53.060015300Z"
        },
        "id": "Tj3MR2u8o-8_"
      },
      "outputs": [],
      "source": [
        "# 从数据集到dataloader\n",
        "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True)\n",
        "val_loader = torch.utils.data.DataLoader(test_ds, batch_size=32, shuffle=False)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([32, 1, 28, 28])\n",
            "torch.Size([32])\n",
            "torch.Size([32, 1, 28, 28])\n",
            "torch.Size([32])\n"
          ]
        }
      ],
      "source": [
        "# 查看数据\n",
        "for datas, labels in train_loader:\n",
        "    print(datas.shape)\n",
        "    print(labels.shape)\n",
        "    break\n",
        "#查看val_loader\n",
        "for datas, labels in val_loader:\n",
        "    print(datas.shape)\n",
        "    print(labels.shape)\n",
        "    break"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T01:58:03.924900200Z",
          "start_time": "2024-07-18T01:58:03.865225700Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ASENEozRo-8_",
        "outputId": "c46a9256-a6b1-4ef9-cf6e-6aea24ecf5c2"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rDo-pyIRo-9A"
      },
      "source": [
        "## 定义模型"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:01:18.583508Z",
          "start_time": "2024-07-18T02:01:18.561874500Z"
        },
        "id": "rxZfS9Zmo-9A"
      },
      "outputs": [],
      "source": [
        "class NeuralNetwork(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.flatten = nn.Flatten()\n",
        "        self.linear_relu_stack = nn.Sequential(\n",
        "            nn.Linear(28 * 28, 300),  # in_features=784, out_features=300\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(300, 100),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(100, 10),\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        # x.shape [batch size, 1, 28, 28]\n",
        "        x = self.flatten(x)\n",
        "        # 展平后 x.shape [batch size, 28 * 28]\n",
        "        logits = self.linear_relu_stack(x)\n",
        "        # logits.shape [batch size, 10]\n",
        "        return logits\n",
        "\n",
        "model = NeuralNetwork()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bxufPZ4jo-9A"
      },
      "source": [
        "## 训练\n",
        "\n",
        "pytorch的训练需要自行实现，包括\n",
        "1. 定义损失函数\n",
        "2. 定义优化器\n",
        "3. 定义训练步\n",
        "4. 训练"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T03:00:32.064832600Z",
          "start_time": "2024-07-18T03:00:32.060565500Z"
        },
        "id": "_pOl2WR2o-9A"
      },
      "outputs": [],
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "\n",
        "@torch.no_grad()\n",
        "def evaluating(model, dataloader, loss_fct):\n",
        "    loss_list = []\n",
        "    pred_list = []\n",
        "    label_list = []\n",
        "    for datas, labels in dataloader:\n",
        "        #datas.shape [batch size, 1, 28, 28]\n",
        "        #labels.shape [batch size]\n",
        "        datas = datas.to(device)\n",
        "        labels = labels.to(device)\n",
        "        # 前向计算\n",
        "        logits = model(datas)\n",
        "        loss = loss_fct(logits, labels)         # 验证集损失\n",
        "        loss_list.append(loss.item()) # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
        "\n",
        "        preds = logits.argmax(axis=-1)    # 验证集预测, axis=-1 表示最后一个维度,因为logits.shape [batch size, 10]，所以axis=-1表示对最后一个维度求argmax，即对每个样本的10个类别的概率求argmax，得到最大概率的类别, preds.shape [batch size]\n",
        "        pred_list.extend(preds.cpu().numpy().tolist()) # tensor转numpy，再转list\n",
        "        label_list.extend(labels.cpu().numpy().tolist())\n",
        "\n",
        "    acc = accuracy_score(label_list, pred_list) # 验证集准确率\n",
        "    return np.mean(loss_list), acc # 返回验证集平均损失和准确率\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "75F6XnPgo-9B"
      },
      "source": [
        "# TensorBoard 可视化\n",
        "\n",
        "pip install tensorboard\n",
        "训练过程中可以使用如下命令启动tensorboard服务。注意使用绝对路径，否则会报错\n",
        "\n",
        "```shell\n",
        " tensorboard  --logdir=\"D:\\BaiduSyncdisk\\pytorch\\chapter_2_torch\\runs\" --host 0.0.0.0 --port 8848\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:43:40.404725900Z",
          "start_time": "2024-07-18T02:43:40.131435400Z"
        },
        "id": "b3cHSvmro-9B"
      },
      "outputs": [],
      "source": [
        "from torch.utils.tensorboard import SummaryWriter\n",
        "\n",
        "\n",
        "class TensorBoardCallback:\n",
        "    def __init__(self, log_dir, flush_secs=10):\n",
        "        \"\"\"\n",
        "        Args:\n",
        "            log_dir (str): dir to write log.\n",
        "            flush_secs (int, optional): write to dsk each flush_secs seconds. Defaults to 10.\n",
        "        \"\"\"\n",
        "        self.writer = SummaryWriter(log_dir=log_dir, flush_secs=flush_secs) # 实例化SummaryWriter, log_dir是log存放路径，flush_secs是每隔多少秒写入磁盘\n",
        "\n",
        "    def draw_model(self, model, input_shape):#graphs\n",
        "        self.writer.add_graph(model, input_to_model=torch.randn(input_shape)) # 画模型图\n",
        "\n",
        "    def add_loss_scalars(self, step, loss, val_loss):\n",
        "        self.writer.add_scalars(\n",
        "            main_tag=\"training/loss\",\n",
        "            tag_scalar_dict={\"loss\": loss, \"val_loss\": val_loss},\n",
        "            global_step=step,\n",
        "            ) # 画loss曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
        "\n",
        "    def add_acc_scalars(self, step, acc, val_acc):\n",
        "        self.writer.add_scalars(\n",
        "            main_tag=\"training/accuracy\",\n",
        "            tag_scalar_dict={\"accuracy\": acc, \"val_accuracy\": val_acc},\n",
        "            global_step=step,\n",
        "        ) # 画acc曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
        "\n",
        "    def add_lr_scalars(self, step, learning_rate):\n",
        "        self.writer.add_scalars(\n",
        "            main_tag=\"training/learning_rate\",\n",
        "            tag_scalar_dict={\"learning_rate\": learning_rate},\n",
        "            global_step=step,\n",
        "        ) # 画lr曲线, main_tag是主tag，tag_scalar_dict是子tag，global_step是步数\n",
        "\n",
        "    def __call__(self, step, **kwargs):\n",
        "        # add loss,把loss，val_loss取掉，画loss曲线\n",
        "        loss = kwargs.pop(\"loss\", None)\n",
        "        val_loss = kwargs.pop(\"val_loss\", None)\n",
        "        if loss is not None and val_loss is not None:\n",
        "            self.add_loss_scalars(step, loss, val_loss) # 画loss曲线\n",
        "        # add acc\n",
        "        acc = kwargs.pop(\"acc\", None)\n",
        "        val_acc = kwargs.pop(\"val_acc\", None)\n",
        "        if acc is not None and val_acc is not None:\n",
        "            self.add_acc_scalars(step, acc, val_acc) # 画acc曲线\n",
        "        # add lr\n",
        "        learning_rate = kwargs.pop(\"lr\", None)\n",
        "        if learning_rate is not None:\n",
        "            self.add_lr_scalars(step, learning_rate) # 画lr曲线\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tgalJLyyo-9B"
      },
      "source": [
        "### Save Best\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:43:42.457851800Z",
          "start_time": "2024-07-18T02:43:42.448940500Z"
        },
        "id": "sIgJ5Dm5o-9B"
      },
      "outputs": [],
      "source": [
        "class SaveCheckpointsCallback:\n",
        "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
        "        \"\"\"\n",
        "        Save checkpoints each save_epoch epoch.\n",
        "        We save checkpoint by epoch in this implementation.\n",
        "        Usually, training scripts with pytorch evaluating model and save checkpoint by step.\n",
        "\n",
        "        Args:\n",
        "            save_dir (str): dir to save checkpoint\n",
        "            save_epoch (int, optional): the frequency to save checkpoint. Defaults to 1.\n",
        "            save_best_only (bool, optional): If True, only save the best model or save each model at every epoch.\n",
        "        \"\"\"\n",
        "        self.save_dir = save_dir # 保存路径\n",
        "        self.save_step = save_step # 保存步数\n",
        "        self.save_best_only = save_best_only # 是否只保存最好的模型\n",
        "        self.best_metrics = -1 # 最好的指标，指标不可能为负数，所以初始化为-1\n",
        "\n",
        "        # mkdir\n",
        "        if not os.path.exists(self.save_dir): # 如果不存在保存路径，则创建\n",
        "            os.mkdir(self.save_dir)\n",
        "\n",
        "    def __call__(self, step, state_dict, metric=None):\n",
        "        if step % self.save_step > 0: #每隔save_step步保存一次\n",
        "            return\n",
        "\n",
        "        if self.save_best_only:\n",
        "            assert metric is not None # 必须传入metric\n",
        "            if metric >= self.best_metrics:\n",
        "                # save checkpoints\n",
        "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\")) # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
        "                # update best metrics\n",
        "                self.best_metrics = metric\n",
        "        else:\n",
        "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\")) # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PvS4Uv5oo-9B"
      },
      "source": [
        "### Early Stop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:43:44.696462800Z",
          "start_time": "2024-07-18T02:43:44.684950500Z"
        },
        "id": "ROGZlrK9o-9C"
      },
      "outputs": [],
      "source": [
        "class EarlyStopCallback:\n",
        "    def __init__(self, patience=5, min_delta=0.01):\n",
        "        \"\"\"\n",
        "\n",
        "        Args:\n",
        "            patience (int, optional): Number of epochs with no improvement after which training will be stopped.. Defaults to 5.\n",
        "            min_delta (float, optional): Minimum change in the monitored quantity to qualify as an improvement, i.e. an absolute\n",
        "                change of less than min_delta, will count as no improvement. Defaults to 0.01.\n",
        "        \"\"\"\n",
        "        self.patience = patience # 多少个epoch没有提升就停止训练\n",
        "        self.min_delta = min_delta # 最小的提升幅度\n",
        "        self.best_metric = -1\n",
        "        self.counter = 0\n",
        "\n",
        "    def __call__(self, metric):\n",
        "        if metric >= self.best_metric + self.min_delta:#用准确率\n",
        "            # update best metric\n",
        "            self.best_metric = metric\n",
        "            # reset counter\n",
        "            self.counter = 0\n",
        "        else:\n",
        "            self.counter += 1 # 计数器加1，下面的patience判断用到\n",
        "\n",
        "    @property\n",
        "    def early_stop(self):\n",
        "        return self.counter >= self.patience\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "data": {
            "text/plain": "80000"
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "500*32*5"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:43:54.503637Z",
          "start_time": "2024-07-18T02:43:54.488870100Z"
        },
        "id": "mFui7IB6o-9C",
        "outputId": "270d351a-fcd6-4d0b-b18a-4feddbe79203"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:45:10.645475Z",
          "start_time": "2024-07-18T02:45:10.620818400Z"
        },
        "id": "IOeGwyllo-9C"
      },
      "outputs": [],
      "source": [
        "# 训练\n",
        "def training(\n",
        "    model,\n",
        "    train_loader,\n",
        "    val_loader,\n",
        "    epoch,\n",
        "    loss_fct,\n",
        "    optimizer,\n",
        "    tensorboard_callback=None,\n",
        "    save_ckpt_callback=None,\n",
        "    early_stop_callback=None,\n",
        "    eval_step=500,\n",
        "    ):\n",
        "    record_dict = {\n",
        "        \"train\": [],\n",
        "        \"val\": []\n",
        "    }\n",
        "\n",
        "    global_step = 0\n",
        "    model.train()\n",
        "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
        "        for epoch_id in range(epoch):\n",
        "            # training\n",
        "            for datas, labels in train_loader:\n",
        "                datas = datas.to(device) # 数据放到device上\n",
        "                labels = labels.to(device) # 标签放到device上\n",
        "                # 梯度清空\n",
        "                optimizer.zero_grad()\n",
        "                # 模型前向计算\n",
        "                logits = model(datas)\n",
        "                # 计算损失\n",
        "                loss = loss_fct(logits, labels)\n",
        "                # 梯度回传，计算梯度，更新参数，这里是更新模型参数\n",
        "                loss.backward()\n",
        "                # 调整优化器，包括学习率的变动等\n",
        "                optimizer.step()\n",
        "                preds = logits.argmax(axis=-1)\n",
        "\n",
        "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
        "                loss = loss.cpu().item()\n",
        "                # record\n",
        "\n",
        "                record_dict[\"train\"].append({\n",
        "                    \"loss\": loss, \"acc\": acc, \"step\": global_step\n",
        "                })\n",
        "\n",
        "                # evaluating\n",
        "                if global_step % eval_step == 0:\n",
        "                    model.eval()  # 切换到验证集模式\n",
        "                    val_loss, val_acc = evaluating(model, val_loader, loss_fct)\n",
        "                    record_dict[\"val\"].append({\n",
        "                        \"loss\": val_loss, \"acc\": val_acc, \"step\": global_step\n",
        "                    })\n",
        "                    model.train() # 切换回训练集模式\n",
        "\n",
        "                    # 1. 使用 tensorboard 可视化\n",
        "                    if tensorboard_callback is not None:\n",
        "                        tensorboard_callback(\n",
        "                            global_step,\n",
        "                            loss=loss, val_loss=val_loss,\n",
        "                            acc=acc, val_acc=val_acc,\n",
        "                            lr=optimizer.param_groups[0][\"lr\"], # 取出当前学习率\n",
        "                            )\n",
        "\n",
        "                    # 2. 保存模型权重 save model checkpoint\n",
        "                    if save_ckpt_callback is not None:\n",
        "                        save_ckpt_callback(global_step, model.state_dict(), metric=val_acc) # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
        "\n",
        "                    # 3. 早停 Early Stop\n",
        "                    if early_stop_callback is not None:\n",
        "                        early_stop_callback(val_acc) # 验证集准确率不再提升，则停止训练\n",
        "                        if early_stop_callback.early_stop:# 验证集准确率不再提升，则停止训练\n",
        "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
        "                            return record_dict\n",
        "\n",
        "                # udate step\n",
        "                global_step += 1\n",
        "                pbar.update(1)\n",
        "                pbar.set_postfix({\"epoch\": epoch_id})\n",
        "\n",
        "    return record_dict"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "outputs": [],
      "source": [
        "epoch = 100\n",
        "\n",
        "model = NeuralNetwork()\n",
        "\n",
        "# 1. 定义损失函数 采用MSE损失\n",
        "loss_fct = nn.CrossEntropyLoss()\n",
        "# 2. 定义优化器 采用SGD\n",
        "# Optimizers specified in the torch.optim package\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
        "\n",
        "# 1. tensorboard 可视化\n",
        "tensorboard_callback = TensorBoardCallback(\"runs\")\n",
        "tensorboard_callback.draw_model(model, [1, 28, 28])\n",
        "# 2. save best\n",
        "save_ckpt_callback = SaveCheckpointsCallback(\"checkpoints\", save_best_only=True)\n",
        "# 3. early stop\n",
        "early_stop_callback = EarlyStopCallback(patience=10)\n"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:52:59.198747Z",
          "start_time": "2024-07-18T02:52:58.899229Z"
        },
        "id": "5a-jKAUTo-9C"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Parameter containing:\n",
              "tensor([ 0.0169, -0.0286, -0.0085, -0.0153, -0.0041,  0.0233,  0.0007,  0.0294,\n",
              "        -0.0260, -0.0341,  0.0094,  0.0079,  0.0262, -0.0111,  0.0245,  0.0115,\n",
              "         0.0337, -0.0129, -0.0134, -0.0010,  0.0197, -0.0238, -0.0158, -0.0065,\n",
              "         0.0278, -0.0013,  0.0283, -0.0062,  0.0152,  0.0120,  0.0259,  0.0288,\n",
              "         0.0022,  0.0189, -0.0126,  0.0202,  0.0241, -0.0071,  0.0092, -0.0187,\n",
              "        -0.0107, -0.0230, -0.0093,  0.0121, -0.0185,  0.0332,  0.0003,  0.0189,\n",
              "        -0.0271, -0.0304,  0.0096,  0.0308, -0.0293, -0.0023, -0.0209, -0.0091,\n",
              "         0.0180, -0.0027, -0.0239, -0.0152, -0.0072, -0.0357,  0.0307, -0.0081,\n",
              "         0.0003,  0.0072, -0.0153, -0.0093,  0.0230, -0.0066,  0.0332,  0.0103,\n",
              "        -0.0351,  0.0252,  0.0337,  0.0247,  0.0165,  0.0229, -0.0153, -0.0318,\n",
              "        -0.0182, -0.0081,  0.0215,  0.0243,  0.0354,  0.0128, -0.0225,  0.0110,\n",
              "        -0.0106,  0.0131, -0.0073, -0.0274,  0.0328, -0.0282,  0.0326,  0.0289,\n",
              "         0.0253, -0.0050,  0.0004,  0.0156, -0.0169, -0.0075,  0.0054, -0.0357,\n",
              "         0.0268,  0.0025, -0.0243, -0.0052, -0.0298,  0.0152, -0.0296, -0.0351,\n",
              "         0.0258,  0.0331, -0.0316, -0.0012,  0.0166,  0.0161,  0.0302,  0.0081,\n",
              "        -0.0062,  0.0353,  0.0326,  0.0207, -0.0118, -0.0274, -0.0242, -0.0340,\n",
              "         0.0017, -0.0316, -0.0229, -0.0247,  0.0098, -0.0115,  0.0007,  0.0058,\n",
              "         0.0132,  0.0124,  0.0314, -0.0326, -0.0021,  0.0232, -0.0059, -0.0004,\n",
              "         0.0078, -0.0110,  0.0195,  0.0312,  0.0036,  0.0013, -0.0276,  0.0341,\n",
              "         0.0037,  0.0276,  0.0056, -0.0074, -0.0267, -0.0148,  0.0103,  0.0183,\n",
              "         0.0038,  0.0301, -0.0170,  0.0332,  0.0122,  0.0233,  0.0179,  0.0184,\n",
              "        -0.0085, -0.0258,  0.0047,  0.0081,  0.0250,  0.0037,  0.0192, -0.0091,\n",
              "         0.0131, -0.0117, -0.0115, -0.0271, -0.0090,  0.0150, -0.0084,  0.0132,\n",
              "        -0.0045,  0.0345,  0.0092,  0.0162, -0.0162, -0.0032,  0.0205,  0.0198,\n",
              "        -0.0018, -0.0278,  0.0230,  0.0081,  0.0284,  0.0121,  0.0328,  0.0196,\n",
              "        -0.0247, -0.0099,  0.0162,  0.0131, -0.0035,  0.0062, -0.0263,  0.0129,\n",
              "         0.0142,  0.0244, -0.0295,  0.0030, -0.0011, -0.0345,  0.0238,  0.0169,\n",
              "         0.0221,  0.0306,  0.0260,  0.0138, -0.0346,  0.0306, -0.0347,  0.0173,\n",
              "        -0.0239, -0.0101, -0.0170,  0.0312, -0.0123, -0.0305, -0.0021,  0.0285,\n",
              "        -0.0088,  0.0179, -0.0057, -0.0130,  0.0064,  0.0067, -0.0157, -0.0267,\n",
              "        -0.0118,  0.0248, -0.0109,  0.0005,  0.0157,  0.0036,  0.0264, -0.0276,\n",
              "         0.0034, -0.0336,  0.0332,  0.0050, -0.0189,  0.0130, -0.0349,  0.0248,\n",
              "         0.0321,  0.0299,  0.0036, -0.0145, -0.0346,  0.0120,  0.0333,  0.0075,\n",
              "        -0.0263, -0.0093,  0.0311,  0.0152, -0.0274, -0.0313,  0.0004, -0.0239,\n",
              "        -0.0143, -0.0261,  0.0301, -0.0332, -0.0208, -0.0270, -0.0269, -0.0325,\n",
              "         0.0059,  0.0266,  0.0229,  0.0299,  0.0024, -0.0078,  0.0269,  0.0038,\n",
              "        -0.0218,  0.0144, -0.0071,  0.0296,  0.0321,  0.0235,  0.0268,  0.0209,\n",
              "        -0.0175, -0.0020,  0.0356,  0.0298], requires_grad=True)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "list(model.parameters())[1] #可学习的模型参数"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:58:22.680524700Z",
          "start_time": "2024-07-18T02:58:22.670552500Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XL36jFfHo-9C",
        "outputId": "a80f902e-a81a-4886-924a-8a6e28a37e2c"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "odict_keys(['linear_relu_stack.0.weight', 'linear_relu_stack.0.bias', 'linear_relu_stack.2.weight', 'linear_relu_stack.2.bias', 'linear_relu_stack.4.weight', 'linear_relu_stack.4.bias'])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ],
      "source": [
        "model.state_dict().keys()"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T02:55:25.887158200Z",
          "start_time": "2024-07-18T02:55:25.876289300Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QcBxTbhjo-9D",
        "outputId": "c1ed7b17-48bb-462e-cf50-4d219735f929"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "  0%|          | 0/187500 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "fcbd2ffa9cb345e6a68495cb909b6ed4"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Early stop at epoch 19 / global_step 36000\n"
          ]
        }
      ],
      "source": [
        "model = model.to(device)\n",
        "record = training(\n",
        "    model,\n",
        "    train_loader,\n",
        "    val_loader,\n",
        "    epoch,\n",
        "    loss_fct,\n",
        "    optimizer,\n",
        "    tensorboard_callback=tensorboard_callback,\n",
        "    save_ckpt_callback=save_ckpt_callback,\n",
        "    early_stop_callback=early_stop_callback,\n",
        "    eval_step=1000\n",
        "    )"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 66,
          "referenced_widgets": [
            "fcbd2ffa9cb345e6a68495cb909b6ed4",
            "0a5a191f4a774d8385e86ab40de6dc19",
            "bd16981f3cab44a58142cb278a92f8c3",
            "db5e36d07bad4ac894bae335ab23706f",
            "710160197aad49f5b997c82518f3196e",
            "ce1de961ef7b4de2b03a90524715bf8a",
            "2da46739413440eb80474ccfe687ef83",
            "51bb53149640442684ec8f62daea1d84",
            "757b2ada417b4042a0c81de2496e0fd5",
            "18defc16ece8431fabaef9053783d7ca",
            "e1400045ba294bc6afa7192c00f23b85"
          ]
        },
        "id": "erd9oFQjo-9D",
        "outputId": "d3093bf3-8942-4898-832e-1721aff7d32a"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0 a\n",
            "1 b\n",
            "2 c\n"
          ]
        }
      ],
      "source": [
        "#帮我写个enumerate例子\n",
        "for i, item in enumerate([\"a\", \"b\", \"c\"]):\n",
        "    print(i, item)"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-04-23T07:26:19.957701200Z",
          "start_time": "2024-04-23T07:26:19.914720400Z"
        },
        "id": "CxKuagxLo-9D",
        "outputId": "a587a1f9-94ec-499b-b403-6d91dad0b40c"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2023-11-20T07:42:43.237109700Z",
          "start_time": "2023-11-20T07:42:43.010089800Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 465
        },
        "id": "VfnDVl3co-9D",
        "outputId": "527d04d6-354d-41b7-9b17-4e4e3d977077"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x500 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "#画线要注意的是损失是不一定在零到1之间的\n",
        "def plot_learning_curves(record_dict, sample_step=500):\n",
        "    # build DataFrame\n",
        "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
        "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
        "\n",
        "    # plot\n",
        "    fig_num = len(train_df.columns) #因为有loss和acc两个指标，所以画个子图\n",
        "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5)) #fig_num个子图，figsize是子图大小\n",
        "    for idx, item in enumerate(train_df.columns):\n",
        "        axs[idx].plot(train_df.index, train_df[item], label=f\"train_{item}\")\n",
        "        axs[idx].plot(val_df.index, val_df[item], label=f\"val_{item}\")\n",
        "        axs[idx].grid()\n",
        "        axs[idx].legend()\n",
        "        x_data=range(0, train_df.index[-1], 5000) #每隔5000步标出一个点\n",
        "        axs[idx].set_xticks(x_data)\n",
        "        axs[idx].set_xticklabels(map(lambda x: f\"{int(x/1000)}k\", x_data)) #map生成labal\n",
        "        axs[idx].set_xlabel(\"step\")\n",
        "\n",
        "    plt.show()\n",
        "\n",
        "plot_learning_curves(record, sample_step=500)  #横坐标是 steps"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nkrmh7xuo-9D"
      },
      "source": [
        "# 评估"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "outputs": [],
      "source": [
        "model = NeuralNetwork() #上线时加载模型\n",
        "model = model.to(device)"
      ],
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T03:03:42.207695300Z",
          "start_time": "2024-07-18T03:03:42.202895700Z"
        },
        "id": "2RBDKHJKo-9D"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "ExecuteTime": {
          "end_time": "2024-07-18T03:03:47.249318Z",
          "start_time": "2024-07-18T03:03:44.700582800Z"
        },
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rYtKPi8ko-9D",
        "outputId": "f24c509f-d99b-4d9b-b699-8b9e5cc60b6d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-17-282285e79dd9>:4: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", map_location=\"cpu\"))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "loss:     0.3634\n",
            "accuracy: 0.8691\n"
          ]
        }
      ],
      "source": [
        "# dataload for evaluating\n",
        "\n",
        "# load checkpoints\n",
        "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\", map_location=\"cpu\"))\n",
        "\n",
        "model.eval()\n",
        "loss, acc = evaluating(model, val_loader, loss_fct)\n",
        "print(f\"loss:     {loss:.4f}\\naccuracy: {acc:.4f}\")"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.8"
    },
    "orig_nbformat": 4,
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "accelerator": "GPU",
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "fcbd2ffa9cb345e6a68495cb909b6ed4": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_0a5a191f4a774d8385e86ab40de6dc19",
              "IPY_MODEL_bd16981f3cab44a58142cb278a92f8c3",
              "IPY_MODEL_db5e36d07bad4ac894bae335ab23706f"
            ],
            "layout": "IPY_MODEL_710160197aad49f5b997c82518f3196e"
          }
        },
        "0a5a191f4a774d8385e86ab40de6dc19": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ce1de961ef7b4de2b03a90524715bf8a",
            "placeholder": "​",
            "style": "IPY_MODEL_2da46739413440eb80474ccfe687ef83",
            "value": " 19%"
          }
        },
        "bd16981f3cab44a58142cb278a92f8c3": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "danger",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_51bb53149640442684ec8f62daea1d84",
            "max": 187500,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_757b2ada417b4042a0c81de2496e0fd5",
            "value": 36000
          }
        },
        "db5e36d07bad4ac894bae335ab23706f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_18defc16ece8431fabaef9053783d7ca",
            "placeholder": "​",
            "style": "IPY_MODEL_e1400045ba294bc6afa7192c00f23b85",
            "value": " 36000/187500 [07:27&lt;25:57, 97.25it/s, epoch=19]"
          }
        },
        "710160197aad49f5b997c82518f3196e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ce1de961ef7b4de2b03a90524715bf8a": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2da46739413440eb80474ccfe687ef83": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "51bb53149640442684ec8f62daea1d84": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "757b2ada417b4042a0c81de2496e0fd5": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "18defc16ece8431fabaef9053783d7ca": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "e1400045ba294bc6afa7192c00f23b85": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}